home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_xemacs.idb / usr / freeware / lib / xemacs-20.4 / lisp / gnus / gnus-soup.el.z / gnus-soup.el
Encoding:
Text File  |  1998-05-21  |  18.1 KB  |  568 lines
  1. ;;; gnus-soup.el --- SOUP packet writing support for Gnus
  2. ;; Copyright (C) 1995,96,97 Free Software Foundation, Inc.
  3.  
  4. ;; Author: Per Abrahamsen <abraham@iesd.auc.dk>
  5. ;;    Lars Magne Ingebrigtsen <larsi@ifi.uio.no>
  6. ;; Keywords: news, mail
  7.  
  8. ;; This file is part of GNU Emacs.
  9.  
  10. ;; GNU Emacs is free software; you can redistribute it and/or modify
  11. ;; it under the terms of the GNU General Public License as published by
  12. ;; the Free Software Foundation; either version 2, or (at your option)
  13. ;; any later version.
  14.  
  15. ;; GNU Emacs is distributed in the hope that it will be useful,
  16. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18. ;; GNU General Public License for more details.
  19.  
  20. ;; You should have received a copy of the GNU General Public License
  21. ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  22. ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23. ;; Boston, MA 02111-1307, USA.
  24.  
  25. ;;; Commentary:
  26.  
  27. ;;; Code:
  28.  
  29. (eval-when-compile (require 'cl))
  30.  
  31. (require 'gnus)
  32. (require 'gnus-art)
  33. (require 'message)
  34. (require 'gnus-start)
  35. (require 'gnus-range)
  36.  
  37. ;;; User Variables:
  38.  
  39. (defvar gnus-soup-directory (nnheader-concat gnus-home-directory "SoupBrew/")
  40.   "*Directory containing an unpacked SOUP packet.")
  41.  
  42. (defvar gnus-soup-replies-directory
  43.   (nnheader-concat gnus-soup-directory "SoupReplies/")
  44.   "*Directory where Gnus will do processing of replies.")
  45.  
  46. (defvar gnus-soup-prefix-file "gnus-prefix"
  47.   "*Name of the file where Gnus stores the last used prefix.")
  48.  
  49. (defvar gnus-soup-packer "tar cf - %s | gzip > $HOME/Soupout%d.tgz"
  50.   "Format string command for packing a SOUP packet.
  51. The SOUP files will be inserted where the %s is in the string.
  52. This string MUST contain both %s and %d.  The file number will be
  53. inserted where %d appears.")
  54.  
  55. (defvar gnus-soup-unpacker "gunzip -c %s | tar xvf -"
  56.   "*Format string command for unpacking a SOUP packet.
  57. The SOUP packet file name will be inserted at the %s.")
  58.  
  59. (defvar gnus-soup-packet-directory gnus-home-directory
  60.   "*Where gnus-soup will look for REPLIES packets.")
  61.  
  62. (defvar gnus-soup-packet-regexp "Soupin"
  63.   "*Regular expression matching SOUP REPLIES packets in `gnus-soup-packet-directory'.")
  64.  
  65. (defvar gnus-soup-ignored-headers "^Xref:"
  66.   "*Regexp to match headers to be removed when brewing SOUP packets.")
  67.  
  68. ;;; Internal Variables:
  69.  
  70. (defvar gnus-soup-encoding-type ?n
  71.   "*Soup encoding type.
  72. `n' is news format, `m' is Unix mbox format, and `M' is MMDF mailbox
  73. format.")
  74.  
  75. (defvar gnus-soup-index-type ?c
  76.   "*Soup index type.
  77. `n' means no index file and `c' means standard Cnews overview
  78. format.")
  79.  
  80. (defvar gnus-soup-areas nil)
  81. (defvar gnus-soup-last-prefix nil)
  82. (defvar gnus-soup-prev-prefix nil)
  83. (defvar gnus-soup-buffers nil)
  84.  
  85. ;;; Access macros:
  86.  
  87. (defmacro gnus-soup-area-prefix (area)
  88.   `(aref ,area 0))
  89. (defmacro gnus-soup-set-area-prefix (area prefix)
  90.   `(aset ,area 0 ,prefix))
  91. (defmacro gnus-soup-area-name (area)
  92.   `(aref ,area 1))
  93. (defmacro gnus-soup-area-encoding (area)
  94.   `(aref ,area 2))
  95. (defmacro gnus-soup-area-description (area)
  96.   `(aref ,area 3))
  97. (defmacro gnus-soup-area-number (area)
  98.   `(aref ,area 4))
  99. (defmacro gnus-soup-area-set-number (area value)
  100.   `(aset ,area 4 ,value))
  101.  
  102. (defmacro gnus-soup-encoding-format (encoding)
  103.   `(aref ,encoding 0))
  104. (defmacro gnus-soup-encoding-index (encoding)
  105.   `(aref ,encoding 1))
  106. (defmacro gnus-soup-encoding-kind (encoding)
  107.   `(aref ,encoding 2))
  108.  
  109. (defmacro gnus-soup-reply-prefix (reply)
  110.   `(aref ,reply 0))
  111. (defmacro gnus-soup-reply-kind (reply)
  112.   `(aref ,reply 1))
  113. (defmacro gnus-soup-reply-encoding (reply)
  114.   `(aref ,reply 2))
  115.  
  116. ;;; Commands:
  117.  
  118. (defun gnus-soup-send-replies ()
  119.   "Unpack and send all replies in the reply packet."
  120.   (interactive)
  121.   (let ((packets (directory-files
  122.           gnus-soup-packet-directory t gnus-soup-packet-regexp)))
  123.     (while packets
  124.       (when (gnus-soup-send-packet (car packets))
  125.     (delete-file (car packets)))
  126.       (setq packets (cdr packets)))))
  127.  
  128. (defun gnus-soup-add-article (n)
  129.   "Add the current article to SOUP packet.
  130. If N is a positive number, add the N next articles.
  131. If N is a negative number, add the N previous articles.
  132. If N is nil and any articles have been marked with the process mark,
  133. move those articles instead."
  134.   (interactive "P")
  135.   (gnus-set-global-variables)
  136.   (let* ((articles (gnus-summary-work-articles n))
  137.      (tmp-buf (get-buffer-create "*soup work*"))
  138.      (area (gnus-soup-area gnus-newsgroup-name))
  139.      (prefix (gnus-soup-area-prefix area))
  140.      headers)
  141.     (buffer-disable-undo tmp-buf)
  142.     (save-excursion
  143.       (while articles
  144.     ;; Find the header of the article.
  145.     (set-buffer gnus-summary-buffer)
  146.     (when (setq headers (gnus-summary-article-header (car articles)))
  147.       ;; Put the article in a buffer.
  148.       (set-buffer tmp-buf)
  149.       (when (gnus-request-article-this-buffer
  150.          (car articles) gnus-newsgroup-name)
  151.         (save-restriction
  152.           (message-narrow-to-head)
  153.           (message-remove-header gnus-soup-ignored-headers t))
  154.         (gnus-soup-store gnus-soup-directory prefix headers
  155.                  gnus-soup-encoding-type
  156.                  gnus-soup-index-type)
  157.         (gnus-soup-area-set-number
  158.          area (1+ (or (gnus-soup-area-number area) 0)))))
  159.     ;; Mark article as read.
  160.     (set-buffer gnus-summary-buffer)
  161.     (gnus-summary-remove-process-mark (car articles))
  162.     (gnus-summary-mark-as-read (car articles) gnus-souped-mark)
  163.     (setq articles (cdr articles)))
  164.       (kill-buffer tmp-buf))
  165.     (gnus-soup-save-areas)))
  166.  
  167. (defun gnus-soup-pack-packet ()
  168.   "Make a SOUP packet from the SOUP areas."
  169.   (interactive)
  170.   (gnus-soup-read-areas)
  171.   (unless (file-exists-p gnus-soup-directory)
  172.     (message "No such directory: %s" gnus-soup-directory))
  173.   (when (null (directory-files gnus-soup-directory nil "\\.MSG$"))
  174.     (message "No files to pack."))
  175.   (gnus-soup-pack gnus-soup-directory gnus-soup-packer))
  176.  
  177. (defun gnus-group-brew-soup (n)
  178.   "Make a soup packet from the current group.
  179. Uses the process/prefix convention."
  180.   (interactive "P")
  181.   (let ((groups (gnus-group-process-prefix n)))
  182.     (while groups
  183.       (gnus-group-remove-mark (car groups))
  184.       (gnus-soup-group-brew (car groups) t)
  185.       (setq groups (cdr groups)))
  186.     (gnus-soup-save-areas)))
  187.  
  188. (defun gnus-brew-soup (&optional level)
  189.   "Go through all groups on LEVEL or less and make a soup packet."
  190.   (interactive "P")
  191.   (let ((level (or level gnus-level-subscribed))
  192.     (newsrc (cdr gnus-newsrc-alist)))
  193.     (while newsrc
  194.       (when (<= (nth 1 (car newsrc)) level)
  195.     (gnus-soup-group-brew (caar newsrc) t))
  196.       (setq newsrc (cdr newsrc)))
  197.     (gnus-soup-save-areas)))
  198.  
  199. ;;;###autoload
  200. (defun gnus-batch-brew-soup ()
  201.   "Brew a SOUP packet from groups mention on the command line.
  202. Will use the remaining command line arguments as regular expressions
  203. for matching on group names.
  204.  
  205. For instance, if you want to brew on all the nnml groups, as well as
  206. groups with \"emacs\" in the name, you could say something like:
  207.  
  208. $ emacs -batch -f gnus-batch-brew-soup ^nnml \".*emacs.*\""
  209.   (interactive)
  210.   nil)
  211.  
  212. ;;; Internal Functions:
  213.  
  214. ;; Store the current buffer.
  215. (defun gnus-soup-store (directory prefix headers format index)
  216.   ;; Create the directory, if needed.
  217.   (gnus-make-directory directory)
  218.   (let* ((msg-buf (nnheader-find-file-noselect
  219.            (concat directory prefix ".MSG")))
  220.      (idx-buf (if (= index ?n)
  221.               nil
  222.             (nnheader-find-file-noselect
  223.              (concat directory prefix ".IDX"))))
  224.      (article-buf (current-buffer))
  225.      from head-line beg type)
  226.     (setq gnus-soup-buffers (cons msg-buf (delq msg-buf gnus-soup-buffers)))
  227.     (buffer-disable-undo msg-buf)
  228.     (when idx-buf
  229.       (push idx-buf gnus-soup-buffers)
  230.       (buffer-disable-undo idx-buf))
  231.     (save-excursion
  232.       ;; Make sure the last char in the buffer is a newline.
  233.       (goto-char (point-max))
  234.       (unless (= (current-column) 0)
  235.     (insert "\n"))
  236.       ;; Find the "from".
  237.       (goto-char (point-min))
  238.       (setq from
  239.         (gnus-mail-strip-quoted-names
  240.          (or (mail-fetch-field "from")
  241.          (mail-fetch-field "really-from")
  242.          (mail-fetch-field "sender"))))
  243.       (goto-char (point-min))
  244.       ;; Depending on what encoding is supposed to be used, we make
  245.       ;; a soup header.
  246.       (setq head-line
  247.         (cond
  248.          ((= gnus-soup-encoding-type ?n)
  249.           (format "#! rnews %d\n" (buffer-size)))
  250.          ((= gnus-soup-encoding-type ?m)
  251.           (while (search-forward "\nFrom " nil t)
  252.         (replace-match "\n>From " t t))
  253.           (concat "From " (or from "unknown")
  254.               " " (current-time-string) "\n"))
  255.          ((= gnus-soup-encoding-type ?M)
  256.           "\^a\^a\^a\^a\n")
  257.          (t (error "Unsupported type: %c" gnus-soup-encoding-type))))
  258.       ;; Insert the soup header and the article in the MSG buf.
  259.       (set-buffer msg-buf)
  260.       (goto-char (point-max))
  261.       (insert head-line)
  262.       (setq beg (point))
  263.       (insert-buffer-substring article-buf)
  264.       ;; Insert the index in the IDX buf.
  265.       (cond ((= index ?c)
  266.          (set-buffer idx-buf)
  267.          (gnus-soup-insert-idx beg headers))
  268.         ((/= index ?n)
  269.          (error "Unknown index type: %c" type)))
  270.       ;; Return the MSG buf.
  271.       msg-buf)))
  272.  
  273. (defun gnus-soup-group-brew (group &optional not-all)
  274.   "Enter GROUP and add all articles to a SOUP package.
  275. If NOT-ALL, don't pack ticked articles."
  276.   (let ((gnus-expert-user t)
  277.     (gnus-large-newsgroup nil)
  278.     (entry (gnus-gethash group gnus-newsrc-hashtb)))
  279.     (when (or (null entry)
  280.           (eq (car entry) t)
  281.           (and (car entry)
  282.            (> (car entry) 0))
  283.           (and (not not-all)
  284.            (gnus-range-length (cdr (assq 'tick (gnus-info-marks
  285.                             (nth 2 entry)))))))
  286.       (when (gnus-summary-read-group group nil t)
  287.     (setq gnus-newsgroup-processable
  288.           (reverse
  289.            (if (not not-all)
  290.            (append gnus-newsgroup-marked gnus-newsgroup-unreads)
  291.          gnus-newsgroup-unreads)))
  292.     (gnus-soup-add-article nil)
  293.     (gnus-summary-exit)))))
  294.  
  295. (defun gnus-soup-insert-idx (offset header)
  296.   ;; [number subject from date id references chars lines xref]
  297.   (goto-char (point-max))
  298.   (insert
  299.    (format "%d\t%s\t%s\t%s\t%s\t%s\t%d\t%s\t\t\n"
  300.        offset
  301.        (or (mail-header-subject header) "(none)")
  302.        (or (mail-header-from header) "(nobody)")
  303.        (or (mail-header-date header) "")
  304.        (or (mail-header-id header)
  305.            (concat "soup-dummy-id-"
  306.                (mapconcat
  307.             (lambda (time) (int-to-string time))
  308.             (current-time) "-")))
  309.        (or (mail-header-references header) "")
  310.        (or (mail-header-chars header) 0)
  311.        (or (mail-header-lines header) "0"))))
  312.  
  313. (defun gnus-soup-save-areas ()
  314.   (gnus-soup-write-areas)
  315.   (save-excursion
  316.     (let (buf)
  317.       (while gnus-soup-buffers
  318.     (setq buf (car gnus-soup-buffers)
  319.           gnus-soup-buffers (cdr gnus-soup-buffers))
  320.     (if (not (buffer-name buf))
  321.         ()
  322.       (set-buffer buf)
  323.       (when (buffer-modified-p)
  324.         (save-buffer))
  325.       (kill-buffer (current-buffer)))))
  326.     (gnus-soup-write-prefixes)))
  327.  
  328. (defun gnus-soup-write-prefixes ()
  329.   (let ((prefixes gnus-soup-last-prefix)
  330.     prefix)
  331.     (save-excursion
  332.       (gnus-set-work-buffer)
  333.       (while (setq prefix (pop prefixes))
  334.     (erase-buffer)
  335.     (insert (format "(setq gnus-soup-prev-prefix %d)\n" (cdr prefix)))
  336.     (gnus-write-buffer (concat (car prefix) gnus-soup-prefix-file))))))
  337.  
  338. (defun gnus-soup-pack (dir packer)
  339.   (let* ((files (mapconcat 'identity
  340.                '("AREAS" "*.MSG" "*.IDX" "INFO"
  341.                  "LIST" "REPLIES" "COMMANDS" "ERRORS")
  342.                " "))
  343.      (packer (if (< (string-match "%s" packer)
  344.             (string-match "%d" packer))
  345.              (format packer files
  346.                  (string-to-int (gnus-soup-unique-prefix dir)))
  347.            (format packer
  348.                (string-to-int (gnus-soup-unique-prefix dir))
  349.                files)))
  350.      (dir (expand-file-name dir)))
  351.     (gnus-make-directory dir)
  352.     (setq gnus-soup-areas nil)
  353.     (gnus-message 4 "Packing %s..." packer)
  354.     (if (zerop (call-process shell-file-name
  355.                  nil nil nil shell-command-switch
  356.                  (concat "cd " dir " ; " packer)))
  357.     (progn
  358.       (call-process shell-file-name nil nil nil shell-command-switch
  359.             (concat "cd " dir " ; rm " files))
  360.       (gnus-message 4 "Packing...done" packer))
  361.       (error "Couldn't pack packet"))))
  362.  
  363. (defun gnus-soup-parse-areas (file)
  364.   "Parse soup area file FILE.
  365. The result is a of vectors, each containing one entry from the AREA file.
  366. The vector contain five strings,
  367.   [prefix name encoding description number]
  368. though the two last may be nil if they are missing."
  369.   (let (areas)
  370.     (save-excursion
  371.       (set-buffer (nnheader-find-file-noselect file 'force))
  372.       (buffer-disable-undo (current-buffer))
  373.       (goto-char (point-min))
  374.       (while (not (eobp))
  375.     (push (vector (gnus-soup-field)
  376.               (gnus-soup-field)
  377.               (gnus-soup-field)
  378.               (and (eq (preceding-char) ?\t)
  379.                (gnus-soup-field))
  380.               (and (eq (preceding-char) ?\t)
  381.                (string-to-int (gnus-soup-field))))
  382.           areas)
  383.     (when (eq (preceding-char) ?\t)
  384.       (beginning-of-line 2)))
  385.       (kill-buffer (current-buffer)))
  386.     areas))
  387.  
  388. (defun gnus-soup-parse-replies (file)
  389.   "Parse soup REPLIES file FILE.
  390. The result is a of vectors, each containing one entry from the REPLIES
  391. file.  The vector contain three strings, [prefix name encoding]."
  392.   (let (replies)
  393.     (save-excursion
  394.       (set-buffer (nnheader-find-file-noselect file))
  395.       (buffer-disable-undo (current-buffer))
  396.       (goto-char (point-min))
  397.       (while (not (eobp))
  398.     (push (vector (gnus-soup-field) (gnus-soup-field)
  399.               (gnus-soup-field))
  400.           replies)
  401.     (when (eq (preceding-char) ?\t)
  402.       (beginning-of-line 2)))
  403.       (kill-buffer (current-buffer)))
  404.     replies))
  405.  
  406. (defun gnus-soup-field ()
  407.   (prog1
  408.       (buffer-substring (point) (progn (skip-chars-forward "^\t\n") (point)))
  409.     (forward-char 1)))
  410.  
  411. (defun gnus-soup-read-areas ()
  412.   (or gnus-soup-areas
  413.       (setq gnus-soup-areas
  414.         (gnus-soup-parse-areas (concat gnus-soup-directory "AREAS")))))
  415.  
  416. (defun gnus-soup-write-areas ()
  417.   "Write the AREAS file."
  418.   (interactive)
  419.   (when gnus-soup-areas
  420.     (nnheader-temp-write (concat gnus-soup-directory "AREAS")
  421.       (let ((areas gnus-soup-areas)
  422.         area)
  423.     (while (setq area (pop areas))
  424.       (insert
  425.        (format
  426.         "%s\t%s\t%s%s\n"
  427.         (gnus-soup-area-prefix area)
  428.         (gnus-soup-area-name area)
  429.         (gnus-soup-area-encoding area)
  430.         (if (or (gnus-soup-area-description area)
  431.             (gnus-soup-area-number area))
  432.         (concat "\t" (or (gnus-soup-area-description
  433.                   area) "")
  434.             (if (gnus-soup-area-number area)
  435.                 (concat "\t" (int-to-string
  436.                       (gnus-soup-area-number area)))
  437.               "")) ""))))))))
  438.  
  439. (defun gnus-soup-write-replies (dir areas)
  440.   "Write a REPLIES file in DIR containing AREAS."
  441.   (nnheader-temp-write (concat dir "REPLIES")
  442.     (let (area)
  443.       (while (setq area (pop areas))
  444.     (insert (format "%s\t%s\t%s\n"
  445.             (gnus-soup-reply-prefix area)
  446.             (gnus-soup-reply-kind area)
  447.             (gnus-soup-reply-encoding area)))))))
  448.  
  449. (defun gnus-soup-area (group)
  450.   (gnus-soup-read-areas)
  451.   (let ((areas gnus-soup-areas)
  452.     (real-group (gnus-group-real-name group))
  453.     area result)
  454.     (while areas
  455.       (setq area (car areas)
  456.         areas (cdr areas))
  457.       (when (equal (gnus-soup-area-name area) real-group)
  458.     (setq result area)))
  459.     (unless result
  460.       (setq result
  461.         (vector (gnus-soup-unique-prefix)
  462.             real-group
  463.             (format "%c%c%c"
  464.                 gnus-soup-encoding-type
  465.                 gnus-soup-index-type
  466.                 (if (gnus-member-of-valid 'mail group) ?m ?n))
  467.             nil nil)
  468.         gnus-soup-areas (cons result gnus-soup-areas)))
  469.     result))
  470.  
  471. (defun gnus-soup-unique-prefix (&optional dir)
  472.   (let* ((dir (file-name-as-directory (or dir gnus-soup-directory)))
  473.      (entry (assoc dir gnus-soup-last-prefix))
  474.      gnus-soup-prev-prefix)
  475.     (if entry
  476.     ()
  477.       (when (file-exists-p (concat dir gnus-soup-prefix-file))
  478.     (ignore-errors
  479.       (load (concat dir gnus-soup-prefix-file) nil t t)))
  480.       (push (setq entry (cons dir (or gnus-soup-prev-prefix 0)))
  481.         gnus-soup-last-prefix))
  482.     (setcdr entry (1+ (cdr entry)))
  483.     (gnus-soup-write-prefixes)
  484.     (int-to-string (cdr entry))))
  485.  
  486. (defun gnus-soup-unpack-packet (dir unpacker packet)
  487.   "Unpack PACKET into DIR using UNPACKER.
  488. Return whether the unpacking was successful."
  489.   (gnus-make-directory dir)
  490.   (gnus-message 4 "Unpacking: %s" (format unpacker packet))
  491.   (prog1
  492.       (zerop (call-process
  493.           shell-file-name nil nil nil shell-command-switch
  494.           (format "cd %s ; %s" (expand-file-name dir)
  495.               (format unpacker packet))))
  496.     (gnus-message 4 "Unpacking...done")))
  497.  
  498. (defun gnus-soup-send-packet (packet)
  499.   (gnus-soup-unpack-packet
  500.    gnus-soup-replies-directory gnus-soup-unpacker packet)
  501.   (let ((replies (gnus-soup-parse-replies
  502.           (concat gnus-soup-replies-directory "REPLIES"))))
  503.     (save-excursion
  504.       (while replies
  505.     (let* ((msg-file (concat gnus-soup-replies-directory
  506.                  (gnus-soup-reply-prefix (car replies))
  507.                  ".MSG"))
  508.            (msg-buf (and (file-exists-p msg-file)
  509.                  (nnheader-find-file-noselect msg-file)))
  510.            (tmp-buf (get-buffer-create " *soup send*"))
  511.            beg end)
  512.       (cond
  513.        ((/= (gnus-soup-encoding-format
  514.          (gnus-soup-reply-encoding (car replies)))
  515.         ?n)
  516.         (error "Unsupported encoding"))
  517.        ((null msg-buf)
  518.         t)
  519.        (t
  520.         (buffer-disable-undo msg-buf)
  521.         (buffer-disable-undo tmp-buf)
  522.         (set-buffer msg-buf)
  523.         (goto-char (point-min))
  524.         (while (not (eobp))
  525.           (unless (looking-at "#! *rnews +\\([0-9]+\\)")
  526.         (error "Bad header"))
  527.           (forward-line 1)
  528.           (setq beg (point)
  529.             end (+ (point) (string-to-int
  530.                     (buffer-substring
  531.                      (match-beginning 1) (match-end 1)))))
  532.           (switch-to-buffer tmp-buf)
  533.           (erase-buffer)
  534.           (insert-buffer-substring msg-buf beg end)
  535.           (goto-char (point-min))
  536.           (search-forward "\n\n")
  537.           (forward-char -1)
  538.           (insert mail-header-separator)
  539.           (setq message-newsreader (setq message-mailer
  540.                          (gnus-extended-version)))
  541.           (cond
  542.            ((string= (gnus-soup-reply-kind (car replies)) "news")
  543.         (gnus-message 5 "Sending news message to %s..."
  544.                   (mail-fetch-field "newsgroups"))
  545.         (sit-for 1)
  546.         (let ((message-syntax-checks
  547.                'dont-check-for-anything-just-trust-me))
  548.           (funcall message-send-news-function)))
  549.            ((string= (gnus-soup-reply-kind (car replies)) "mail")
  550.         (gnus-message 5 "Sending mail to %s..."
  551.                   (mail-fetch-field "to"))
  552.         (sit-for 1)
  553.         (message-send-mail))
  554.            (t
  555.         (error "Unknown reply kind")))
  556.           (set-buffer msg-buf)
  557.           (goto-char end))
  558.         (delete-file (buffer-file-name))
  559.         (kill-buffer msg-buf)
  560.         (kill-buffer tmp-buf)
  561.         (gnus-message 4 "Sent packet"))))
  562.     (setq replies (cdr replies)))
  563.       t)))
  564.  
  565. (provide 'gnus-soup)
  566.  
  567. ;;; gnus-soup.el ends here
  568.